home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / dev / devFsOpTable.h < prev    next >
C/C++ Source or Header  |  1992-12-18  |  7KB  |  170 lines
  1. /*
  2.  * devFsOpTable.h --
  3.  *
  4.  *    The DEVICE operation switch is defined here.  This is the main
  5.  *    interface between the file system and the device drivers.
  6.  *
  7.  * Copyright 1987 Regents of the University of California
  8.  * All rights reserved.
  9.  * Permission to use, copy, modify, and distribute this
  10.  * software and its documentation for any purpose and without
  11.  * fee is hereby granted, provided that the above copyright
  12.  * notice appear in all copies.  The University of California
  13.  * makes no representations about the suitability of this
  14.  * software for any purpose.  It is provided "as is" without
  15.  * express or implied warranty.
  16.  *
  17.  *
  18.  * $Header: /cdrom/src/kernel/Cvsroot/kernel/dev/devFsOpTable.h,v 9.3 91/04/16 17:12:55 jhh Exp $ SPRITE (Berkeley)
  19.  */
  20.  
  21. #ifndef _DEVOPTABLE 
  22. #define _DEVOPTABLE
  23.  
  24. #include <sprite.h>
  25. #include <user/fs.h>
  26. #include <devBlockDevice.h>
  27.  
  28. /*
  29.  * Device type specific operations, calling sequence defined below.
  30.  *    DeviceOpen
  31.  *    DeviceRead
  32.  *    DeviceWrite
  33.  *    DeviceIOControl
  34.  *    DeviceClose
  35.  *    DeviceSelect
  36.  *    BlockDeviceAttach
  37.  *    DeviceReopen
  38.  *    DeviceMMap
  39.  */
  40.  
  41. typedef struct DevFsTypeOps {
  42.     int         type;    /* One of the device types. See devNumbersInt.h */
  43.     /*
  44.      * Device Open - called during an open of a device file.
  45.      *    (*openProc)(devicePtr, flags, notifyToken)
  46.      *        Fs_Device *devicePtr;        (Identifies device)
  47.      *        int flags;            (FS_READ, FS_WRITE, FS_APPEND)
  48.      *        Fs_NotifyToken notifyToken;    (Handle on device used with
  49.      *                        (Fs_NotifyWriter/Reader calls)
  50.      *            int *flagsPtr;                    (OUT: Device IO flags)
  51.      */
  52.     ReturnStatus (*open) _ARGS_ ((Fs_Device *devicePtr, int flags,
  53.                               Fs_NotifyToken notifyToken, int *flagsPtr));
  54.     /*
  55.      * Device Read - called to get data from a device.
  56.      * Device Write - called to pass data to a device.
  57.      *
  58.      * Both Read and Write take a Fs_IOParam record that indicates the
  59.      * buffer, length, and offset of the transfer.  There is also
  60.      * procID, familyID, and uid information for additional permission checks.
  61.      * The length, buffer, and offset should be kept read-only because
  62.      * they may be re-used by higher levels.
  63.      * These also take a Fs_IOReply record that should be updated to
  64.      * reflect the length transferred, and a signal/code to generate.
  65.      * The length, signal, and code are all initialized to zero before
  66.      * the call into the device driver.
  67.      *
  68.      *    (*readProc)(devicePtr, readPtr, replyPtr)
  69.      *        Fs_Device *devicePtr;        (Identifies device)
  70.      *        Fs_IOParam *readPtr;        (See above comments)
  71.      *        Fs_IOReply *replyPtr;        (See above comments)
  72.      *    (*writeProc)(devicePtr, writePtr, replyPtr)
  73.      *        Fs_Device *devicePtr;        (Identifies device)
  74.      *        Fs_IOParam *writePtr;        (See above comments)
  75.      *        Fs_IOReply *replyPtr;        (See above comments)
  76.      */
  77.     ReturnStatus (*read) _ARGS_ ((Fs_Device *devicePtr, Fs_IOParam *readPtr,
  78.                               Fs_IOReply *replyPtr));
  79.     ReturnStatus (*write) _ARGS_ ((Fs_Device *devicePtr, Fs_IOParam *writePtr,
  80.                                Fs_IOReply *replyPtr));
  81.     /*
  82.      * Device I/O Control - perform a device-specific operation
  83.      * This takes an Fs_IOCParam record that specifies the inBuffer,
  84.      * inBufSize, outBuffer, and outBufSize.  It also indicates
  85.      * the command, byteOrder, procID, familyID, and uid.
  86.      * The driver is responsible for fixing up the contents of the
  87.      * inBuffer to match mach_ByteOrder, and fixing up the contents
  88.      * of the outBuffer to match ioctlPtr->byteOrder.
  89.      * The Fs_IOReply is used as in read and write.  The length is
  90.      * initialized to ioctlPtr->outBufSize, so normally this doesn't
  91.      * have to be modified.
  92.      *
  93.      *    (*ioctlProc)(devicePtr, ioctlPtr, replyPtr)
  94.      *        Fs_Device *devicePtr;        (Identifies device)
  95.      *        Fs_IOCParam *ioctlPtr;        (See above comments)
  96.      *        Fs_IOReply *replyPtr;        (See above comments)
  97.      */
  98.     ReturnStatus (*ioctl) _ARGS_ ((Fs_Device *devicePtr, Fs_IOCParam *ioctlPtr,
  99.                                Fs_IOReply *replyPtr));
  100.     /*
  101.      * Device Close - close a stream to a device.
  102.      *    (*closeProc)(devicePtr, flags, numUsers, numWriters)
  103.      *        Fs_Device *devicePtr;        (Identifies device)
  104.      *        int flags;            (Stream usage flags)
  105.      *        int numUsers;            (Number of active streams left)
  106.      *        int numWriters;            (Number of writers left)
  107.      */
  108.     ReturnStatus (*close) _ARGS_ ((Fs_Device *devicePtr, int flags,
  109.                                int numUsers, int numWriters));
  110.     /*
  111.      * Device Select - poll a device for readiness
  112.      *    (*selectProc)(devicePtr, readPtr, writePtr, exceptPtr)
  113.      *        Fs_Device *devicePtr;        (Identifies device)
  114.      *        int *readPtr;            (Readability bit)
  115.      *        int *writePtr;            (Writability bit)
  116.      *        int *exceptPtr;            (Exception bit)
  117.      */
  118.     ReturnStatus (*select) _ARGS_ ((Fs_Device *devicePtr, int *readPtr,
  119.                                 int *writePtr, int *exceptPtr));
  120.     /*
  121.      * Block Device Attach - attach a block device at boot-time.
  122.      *    (*attachProc)(devicePtr)
  123.      *        Fs_Device *devicePtr;        (Identifies device)
  124.      */
  125.     DevBlockDeviceHandle *((*blockDevAttach) _ARGS_ ((Fs_Device *devicePtr)));
  126.     /*
  127.      * Reopen Device -  called during recovery to reestablish a stream
  128.      *    (*reopenProc)(devicePtr, numUsers, numWriters, notifyToken)
  129.      *        Fs_Device *devicePtr;        (Identifies device)
  130.      *        int numUsers;            (Number of active streams)
  131.      *        int numWriters;            (Number of writers)
  132.      *        Fs_NotifyToken notifyToken    (Handle on device used with
  133.      *                        (Fs_NotifyWriter/Reader calls)
  134.      *            int *flagsPtr;                    (OUT: Device IO flags)
  135.      */
  136.     ReturnStatus (*reopen) _ARGS_ ((Fs_Device *devicePtr, int numUsers,
  137.                                 int numWriters,
  138.                     Fs_NotifyToken notifyToken,
  139.                     int *flagsPtr));
  140.     /*
  141.      * MMap Device -  called to map device memory into user space.
  142.      *    (*mmapProc)(devicePtr, startAddr, length, offset, newAddrPtr)
  143.      *        Fs_Device *devicePtr;        (Identifies device)
  144.      *        Address startAddr;        (Requested starting virt. addr.)
  145.      *        int length;            (Length of mapped segment)
  146.      *        int offset;            (Offset into mapped file)
  147.      *        Address *newAddrPtr;        (User address really mapped at)
  148.      */
  149.     ReturnStatus (*mmap) _ARGS_ ((Fs_Device *devicePtr, Address startAddr,
  150.                               int length, int offset, Address *newAddrPtr));
  151. } DevFsTypeOps;
  152.  
  153. extern DevFsTypeOps devFsOpTable[];
  154. extern int devNumDevices;
  155.  
  156. /*
  157.  * DEV_TYPE_INDEX() - Compute the index into the devFsOpTable from the
  158.  *              type field from of the Fs_Device structure.
  159.  */
  160.  
  161. #define    DEV_TYPE_INDEX(type)    ((type)&0xff)
  162. /*
  163.  * A list of disk device Fs_Device structure that is used when probing for a
  164.  * disk. Initialized in devConfig.c.
  165.  */
  166. extern Fs_Device devFsDefaultDiskPartitions[];
  167. extern int devNumDefaultDiskPartitions;
  168.  
  169. #endif /* _DEVOPTABLE */
  170.